Как сделать так, чтобы два метода вызывали друг друга?

Я немного запутался в том, как заставить два метода вызывать друг друга (т.е. иметь A() call B() и B() call A()). Кажется, что F # «видит» метод только после того, как он был обнаружен в коде, поэтому, если он не был обнаружен, он просто сообщает, что значение или конструктор не определены.

Мне здесь не хватает чего-то очень простого?


f# mutual-recursion
person Dmitri Nesteruk    schedule 25.03.2009    source источник

Ответы (4)


arrow_upward
46
arrow_downward

'let rec ... and ...' - это искомый синтаксис.

let rec F() = 
    G()
and G() =
    F()

См. Также Приключения в совместной рекурсии F # < / а>.

person Brian    schedule 25.03.2009
comment
Лучшее решение. Однако, если нам нужно заставить A () вызвать B (), а B () вызвать A (), то с нашим функциональным дизайном что-то не так. В идеале мы не должны столкнуться с такой ситуацией. Поправьте меня, если я ошибаюсь. - person ozgur; 23.10.2018
comment
@ozgur представьте, что вы хотите создать парсер JSON. Тогда вам понадобится функция, которая анализирует списки, элементы которых могут быть объектами. И вам нужна функция, которая анализирует объекты, значения которых могут быть списками. Этот тип рекурсии не так редок, как вы думаете. - person The Hoff; 10.02.2019

arrow_upward
22
arrow_downward

Поскольку вопрос касается методов, а ответ Брайана касается функций, возможно, будет полезно указать, что вы можете использовать аналогичный синтаксис для типов:

type A() =
    let b = new B()
    member x.MethodA() = b.MethodB()
and B() =
    member x.MethodB() = ()

Также обратите внимание, что члены по умолчанию имеют «let rec» (на самом деле я не думаю, что они могут быть не рекурсивными).

person Kurt Schelfthout    schedule 25.03.2009

arrow_upward
9
arrow_downward

F # 4.1 представляет взаимно рекурсивные модули и пространства имен.

Это альтернатива ключевому слову and.

module rec PingPong = // <------ rec keyword here.

    let pong() = 
        printfn "pong"
        ping() 

    let ping () = 
        printfn "ping"
        pong()

Ключевое слово rec определяет модули и пространства имен, которые «позволяют всему содержащемуся коду быть взаимно рекурсивным».

person Shaun Luttin    schedule 23.02.2018

arrow_upward
5
arrow_downward

Функции, объявленные через let

let rec a () = b ()
and b () = ()

Это взаимно рекурсивные функции.

Методы одного типа

type T () =
    member t.A () = t.B()
    member t.B () = ()

Это тривиально; это просто работает. Обратите внимание на комментарий Абеля.

Методы разных типов

type TypeA () =
    member t.A (b : TypeB) = b.B()

and TypeB () =
    member b.B () = ()

Здесь используется синтаксис type ... and для взаимно рекурсивных типов.

Примечания

Обычно and используется только в том случае, если вызовы происходят в обоих направлениях. В противном случае может быть лучше переупорядочить объявления так, чтобы вызываемая функция была первой. Часто бывает полезно для вывода типов и удобочитаемости, чтобы избежать циклических зависимостей и не подразумевать их там, где они не используются.

Я предлагаю отредактировать вопрос, чтобы либо запрашивать функции в целом, либо запрашивать разные типы (в этом случае я бы удалил первые два случая из этого ответа). Методы обычно считаются подмножеством функций, что является общим математическим термином. Однако все функции F # технически являются методами интерфейса командной строки, так как это то, для чего они скомпилированы. Как есть, неясно, о чем вопрос, но я предполагаю из принятого ответа, что он не только запрашивает методы, как следует из названия.

person Vandroiy    schedule 07.11.2014
comment
О методах разных типов вы говорите, что это тривиально; он просто работает, но есть тонкость, которую легко упускать из виду: когда вы используете inline и / или определенные ограничения членов, вам может потребоваться объявить их по порядку (т. е. обратные ссылки приведут к странным и трудно диагностируемым ошибкам). См. Отчет об ошибке. Важен порядок элементов типа - person Abel; 22.12.2016