Вопрос по – Что означает -> в F #?

23

Я некоторое время пытался войти и выключить F #, но меня все время откладывают. Зачем?

Потому что независимо от того, кто "новичок" ресурс, который я пытаюсь посмотреть, я вижу очень простые примеры, которые начинают использовать оператор->.

Тем не менее, пока я не нашел нигде, который бы дал ясное простое объяснение того, что означает этот оператор. Как будто это должно быть настолько очевидно, что не нужно объяснения даже для завершения новичков.

Поэтому я должен быть действительно плотным или, может быть, это почти 3 десятилетия предыдущего опыта, удерживающего меня.

Может кто-нибудь объяснить, объяснить или указать на действительно доступный ресурс, который это объясняет?

Мне все это действительно кажется греческим. Brettski
Просто назовите его Мафусаил. Ryan Lundy
На самом деле Мафусаил прожил 969 лет, поэтому я все равно буду на треть его возраста. Однако отредактировал спасибо;) AnthonyWJones
Если бы используемой единицей возраста был фактически лунный месяц, у нас был бы Метузела, умирающий в зрелом возрасте 75 лет - что вполне заслуживает доверия и, безусловно, заслуживает внимания в пустынном кочевнике. Peter Wone

Ваш Ответ

9   ответов
1

я просто хочу добавить к разговору еще один способ думать об этом.

& APOS; - & GT; & APOS; значит функция.

'a - & gt; «b» - это функция, которая принимает «a» и возвращает «a» b.

('a *' b) - & gt; («c *» d) представляет собой функцию, которая принимает кортеж типа («a», «b») и возвращает кортеж «(c, d»). Например, int / string возвращает float / char.

Где это становится интересным, так это в каскадном случае 'a - & gt; & b; & gt; & APOS; с. Это функция, которая принимает «a» и возвращает функцию («b -» с), или функцию, которая принимает «b -»; & APOS; с.

Так что если вы напишите:  пусть f x y z = ()

Тип будет f: 'a - & gt; & b; & gt; & c; & gt; единицы, поэтому, если вы примените только первый параметр, результатом будет функция с карри "& b; & gt; & c; & gt; & APOS; блок.

9

- & gt; в F # совпадает с = & gt; в C # (я думаю, что вы читаете это "идет в").

- & gt; Оператор также может быть найден в контексте сопоставления с образцом

match x with
| 1 -> dosomething
| _ -> dosomethingelse

Я не уверен, является ли это также лямбда-выражением или чем-то еще, но я предполагаю, что «идет к» все еще держит.

Возможно, то, что вы действительно имеете в виду, это F # parser 'cryptic' ответы:

> let add a b = a + b
val add: int -> int -> int

Это означает (как объясняет большинство примеров), что add представляет собой «val». это берет два целых и возвращает int. Для меня это было совершенно непрозрачно с самого начала. Я имею в виду, откуда мне знать, что add не является val, который принимает одно целое и возвращает два целых числа?

Ну, дело в том, что в некотором смысле это так. Если я добавлю только один int, я получу обратно (int -> gt):

> let inc = add 1
val inc: int -> int

Это (карри) - одна из тех вещей, которые делают F # такой сексуальной для меня.

Что касается полезной информации о F #, я обнаружил, что блоги на FAR более полезны, чем любая официальная «документация». Вот некоторые названия, которые следует проверить

Dustin Campbell (that's diditwith.net, cited in another answer) Don Symes ('the' man) Tomasp.net (aka Tomas Petricek) Andrew Kennedy (for units of measure) Fsharp.it (famous for the Project Euler solutions) http://lorgonblog.spaces.live.com/Blog (aka Brian) Jomo Fisher
46

& APOS; - & Gt; & APOS; не оператор. и его значение зависит от того, как он используется как часть более крупной конструкции.

Внутри типа "-" & gt; " описывает типы функций, как люди описали выше. Например

let f : int -> int = ...

говорит, что "f" это функция, которая принимает int и возвращает int.

Внутри лямбды («вещь, которая начинается с« забавного »ключевого слова»), «-»; это синтаксис, который отделяет аргументы от тела. Например

fun x y -> x + y + 1

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

Внутри "совпадения" конструкция "-" это синтаксис, который отделяет шаблоны от кода, который должен выполняться, если шаблон соответствует. Например, в

match someList with
| [] -> 0
| h::t -> 1

материал слева от каждого '- & gt;' являются шаблонами, и материал справа - это то, что происходит, если шаблон слева был подобран.

Трудность в понимании может быть коренится в ошибочном предположении, что "-" является "оператором" с одним смыслом. Аналогия может быть "." в C #, если вы никогда раньше не видели кода, и попробуйте проанализировать & quot;. & quot; оператор, основанный на просмотре "метода obj.Method" и "3.14"; и «System.Collections», вы можете очень запутаться, потому что символ имеет разные значения в разных контекстах. Как только вы узнаете достаточно языка, чтобы распознать эти контексты, все станет ясно.

Error: User Rate Limit ExceededforError: User Rate Limit Exceededdo yield ([for i in 0..n -> i]).
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded AnthonyWJones
Error: User Rate Limit Exceeded AnthonyWJones
1

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

Для тех, кто знаком с пониманием C # - & gt; быть таким же, как = & gt; Выражение ламба - хороший первый шаг. Это использование: -

fun x y -> x + y + 1

Может пониматься как эквивалент: -

(x, y) => x + y + 1;

Однако ясно, что - & gt; имеет более фундаментальное значение, которое вытекает из концепции о том, что функция, которая принимает два параметра, таких как приведенные выше, может быть уменьшена (это правильный термин?) до серии функций, принимающих только один параметр.

Следовательно, когда вышеизложенное описано следующим образом:

Int -> Int -> Int

Это действительно помогло узнать - & gt; является правой ассоциативной, следовательно, вышеизложенное можно считать:

Int -> (Int -> Int)

Ага! У нас есть функция, которая принимает Int и возвращает (Int -> Int) (функция карри?).

Объяснение, что - & gt; может также появиться как часть определения типа также помогло. (Int -> Int) - это тип любой функции, которая принимает Int и возвращает Int.

Также полезно - & gt; появляется в другом синтаксисе, таком как сопоставление, но там он не имеет того же значения? Это верно? Я не уверен, что это так. Я подозреваю, что это имеет то же значение, но у меня пока нет слов, чтобы выразить это.

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

Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
0

как Haskell (он очень похож на F #, но я не знаю точного синтаксиса - это должно помочь вам понять ->, однако), что вы можете применять только части аргумента, создаватьcurried функции:

adder n x y = n + x + y

Другими словами: «дайте мне три вещи, и я добавлю их вместе». Когда вы кидаете числа в него, компилятор выводит типы n x и y. Скажи, что ты пишешь

adder 1 2 3

Тип 1, 2 и 3 - Int. Следовательно:

adder :: Int -> Int -> Int -> Int

То есть, дайте мне три целых числа, и я, в конце концов, стану целым числом или скажу то же самое:

five :: Int
five = 5

Но вот хорошая часть! Попробуй это:

add5 = adder 5

Как вы помните, adder принимает int, int, int и возвращает вам int. Однако это не вся правда, как вы скоро увидите. На самом деле, add5 будет иметь такой тип:

add5 :: Int -> Int -> Int

Это будет так, как если бы вы «сняли» целых чисел (крайний левый) и приклеил его непосредственно к функции. Присмотревшись к сигнатуре функции, мы заметим, что - & gt; являются правоассоциативными, т.е.

addder :: Int -> (Int -> (Int -> Int))

Это должно прояснить это: когда вы дадите сумматору первое целое число, оно будет оцениваться по отношению к любому значению справа от первой стрелки или:

add5andtwomore :: Int -> (Int -> Int)
add5andtwomore = adder 5

Теперь вы можете использовать add5andtwomore вместо & quot; adder 5 & quot ;. Таким образом, вы можете применить другое целое число, чтобы получить (скажем) & quot; add5and7andonemore & quot ;:

add5and7andonemore :: Int -> Int
add5and7andonemore = adder 5 7

Как видите, add5and7andone больше хочет точно другой аргумент, и когда вы его дадите, он внезапно станет целым числом!

  > add5and7andonemore 9
 => ((add5andtwomore) 7) 9
 => ((adder 5) 7) 9)
<=> adder 5 7 9

Подставляя параметры сумматору (n x y) для (5 7 9), получим:

  > adder 5 7 9 = 5 + 7 + 9
 => 5 + 7 + 9
 => 21

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

  > 5 + 7 + 9
 => (+ 5 (+ 7 9))
 => (+ 5 16)
 => 21

Вот и вы!

12

преобразовано в" или что-то типа того.

Итак, изF # через 20 минут руководство,

> List.map (fun x -> x % 2 = 0) [1 .. 10];;
val it : bool list
= [false; true; false; true; false; true; false; true; false; true]

The code (fun i -> i % 2 = 0) defines an anonymous function, called a lambda expression, that has a parameter x and the function returns the result of "x % 2 = 0", which is whether or not x is even.

Error: User Rate Limit Exceededresearch.microsoft.com/fsharp/manual/lexyacc.aspx
1

Microsoft:

Function types are the types given to first-class function values and are written int -> int. They are similar to .NET delegate types, except they aren't given names. All F# function identifiers can be used as first-class function values, and anonymous function values can be created using the (fun ... -> ...) expression form.

1

=> из лямбда-выражения в C # 3.0.

F#: let f = fun x -> x*x
C#: Func<int, int> f = x => x * x;

-> в F # также используется в сопоставлении с образцом, где это означает: если выражение соответствует части между| а также->то что будет после-> должны быть возвращены в результате:

let isOne x = match x with
 | 1 -> true
 | _ -> false
4

(a -> b) означает «функцию от a до b».. Например, f: (int -> String) означает, что f ссылается на функцию, которая принимает целое число и возвращает строку. Он также используется в качестве consttructor таких значений, как в

val f : (int -> int) = fun n -> n * 2

который создает значение, которое является функцией от некоторого числа n до того же числа, умноженного на два.

Похожие вопросы