LINUX.ORG.RU
Форум — Development  

Генератор на функциях в F#

 


1

3

Можно ли сделать чтобы функция возвращала результат и функцию, которая возвращает следующий результат и функцию, которая ... ммм? спасибо.

Примерчик. 

        let clos = ref [1]        
        let rec continuation () =
            match !clos with
            | [] -> None
            | _ ->                
                if worldChanged then clos := [] 
                Some(!clos, continuation)

прикол именно в том, чтобы функция возвращала себя новую, а не в том чтобы сделать генератор типа счетчика с созданием объекта, инкапсуляцией и прочими прелестями.

★★★

Последнее исправление: pseudo-cat (всего исправлений: 3)
← Помогите с регуляркой
Небольшой вопрос про память →

Очевидно, что это функция вида a -> (a, (a -> (a, a -> (a, ....))) и ее тип вывести невозможною

cyanide_regime
()

Я тоже размышлял над такими stateless итераторами:

(define (iterator->list iter)
        (match (iter)
               ((quote done) null)
               ((list val proc) (cons val (iterator->list proc)))))

(define (list->iterator lst)
        (lambda ()
                (if (null? lst)
                    'done
                    (list (car lst)
                          (list->iterator (cdr lst))))))

(define (itake n iter)
        (lambda ()
                (if (zero? n)
                    'done
                    (match (iter)
                           ((quote done) 'done)
                           ((list val proc) (list val
                                                  (itake (- n 1) proc)))))))

(define (chain iter1 iter2)
        (lambda ()
                (match (iter1)
                       ((quote done) (iter2))
                       ((list val proc) (list val
                                              (chain proc iter2))))))

(define (imap fun iter)
        (lambda ()
                (match (iter)
                       ((quote done) 'done)
                       ((list val proc) (list (fun val)
                                              (imap fun proc))))))

(define (count start (step 1))
        (lambda ()
                (list start (count (+ start step) step))))

(define (take-while fun iter)
        (lambda ()
                (match (iter)
                       ((quote done) 'done)
                       ((list val proc)
                        (if (fun val)
                            (list val (take-while fun proc))
                            'done)))))

(define (cycle iter)
        (letrec ((loop
                    (lambda (iter*)
                            (lambda ()
                                    (match (iter*)
                                           ((quote done) ((cycle iter)))
                                           ((list val proc) (list val (loop proc))))))))
                (loop iter)))


(define (ifilter fun iter)
        (lambda ()
                (letrec ((loop
                            (lambda (iter)
                                    (match (iter)
                                           ((quote done) 'done)
                                           ((list val proc)
                                            (if (fun val)
                                                (list val (ifilter fun proc))
                                                (loop proc)))))))
                        (loop iter))))

(define (ifib)
        (letrec ((loop
                    (lambda (current next)
                            (lambda ()
                                    (list current (loop next (+ current next)))))))
                (loop 1 1)))
komputikisto
()

Напрямую нельзя, ибо бесконечный тип выходит. 

type 'a Rec = Rec of 'a * (unit -> 'a Rec) | Yolo

let clos = ref [1]        
let rec continuation () =
            match !clos with
            | [] -> Yolo
            | _ ->                
                if true then clos := [] 
                Rec (!clos, continuation)

anonymous
()

Ты об этом?

type Automata<'a, 'b> = Automata of ('a -> 'b * Automata<'a, 'b>)

Автомат. По входу возвращаем выход и следующее состояние автомата. Это - стрелка. В Haskell даже есть специальный синтаксис для них. Еще известна в литературе как тип Circuit.

dave ★★★★★
()
Ответ на: комментарий от dave

не совсем, но спасибо что напомнил, что такое было в курсе дискретки в универе

pseudo-cat ★★★
() автор топика
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.
← Помогите с регуляркой
Development
Небольшой вопрос про память →