F# Zen - ROT13

F# Zen - ROT13 | Tmao Coders

F# Zen - ROT13 | Tmao Coders — Sat, 08 Nov 2008 01:40:43 GMT

PingBack from http://www.tmao.info/f-zen-rot13/

re: F# Zen - ROT13

Sergi Mansilla — Sat, 08 Nov 2008 12:23:56 GMT

I like how F# makes the algorithm be so simple and elegant, and I didn't know about this super simple way of casting chars into ints, thanks!

I recently made a F# implementation of Bruce Schneier's Solitaire encryption algorithm, you might want to check it out: http://www.sergimansilla.com/blog/?p=24

Your opinion will be really appreciated :)

Thanks for your articles!

re: F# Zen - ROT13

Robert McCall — Sat, 08 Nov 2008 23:53:01 GMT

I feel uneasy about nitpicking like this, but it is even simpler via module [b]Microsoft.FSharp.Core.String[/b]'s [b]map[/b] function:

[code]let encryptText (s:string) =

s |> String.map (int >> ((+) 13) >> char)

let decryptText (s:string) =

s |> String.map (int >> ((+) -13) >> char)

[/code]

And thanks for the first practical (and beautifully elegant) use I've seen so far of fct composition -- I'm sure there are more to be discovered.

And, officially, everything about F# is tremendous from the lang design to the docs to shipping the source code. You guys have set the new standard for combining high-level cs theory, real-world programmer productivity and exe performance. After 20 years of professional programming (mostly C/C++/C# and various db systems), you guys have me excited about programming again.

-Robert

[i]"Lasting Peace and Happiness for [u][b]ALL[/b][/u] human beings."[/i]

re: F# Zen - ROT13

Carsten K. — Mon, 10 Nov 2008 08:35:56 GMT

well I guess I give my 25cents too:

You will see a lot of ROT13 "encrypted" messages in the usenet (to "hide" a solution, mark a spoiler etc.). In order to make your code really work there you will have to take care of some cases:

1) normaly only [a-z], [A-Z] gets encrypted so a->n, A->N but !->! for example.

2) You don't need a decrypt-function in those cases ;) - it's the same as the encryption function

re: F# Zen - ROT13

Patrick Dewane — Mon, 10 Nov 2008 17:03:37 GMT

At 13 characters, you're already halfway through the alphabet. Meaning you could have just 1 function for encrypting and decrypting.

re: F# Zen - ROT13

ChrSmith — Mon, 10 Nov 2008 20:14:09 GMT

@Patrick,

True, but if and only if you modulo the integer value of each character with 26. Since I'm blindly adding 13, 'z' becomes something outside the typical ASCII plane...

That's exactly why I didn't clame this 'was' an exact implementation of ROT13, but equivocated with 'primitive implementation of ROT13 / Ceasar Cipher'.

But yes, you are right. If you did the extra work you would only need one function for encrypting and decrypting.

re: F# Zen - ROT13

Patrick Dewane — Tue, 11 Nov 2008 16:39:51 GMT

How does one "read" the line:

Array.map (int >> ((+) 13) >> char)

I like to apply a natural language to something I'm trying to learn, but I'm not sure of the correct way to say what this is doing.

re: F# Zen - ROT13

ChrSmith — Tue, 11 Nov 2008 20:55:00 GMT

That is the beauty of function composition :)

I'll probabaly need to devote an entire post to concept later, but in short:

Array.map takes a function which converts the array element to some new value. So in the context of ROT13 transforms a char to a new char.

[int >> (+) 13 >> char] is actually three functions glued together using the function composition operator (>>).

[int] takes an input and converts it to an integer, so 'A' is converted to 65.

[(+) 13] is the (+) function with the first parameter specified as 13, so it is a function that takes an input of an integer and returns 13 plus that integer.

[char] takes an input and converts it to a character. So 65' is converted to 'A'.

By composing those three functions [int >> (+) 13 >> char] the result is a new function that takes anything, converts it to an integer, adds 13, and converts that to a character.

So when applied via Array.map it encrypts the input string.

Function composition is one of the core conepts of functional programming, but definitely requires a bit of time to wrap your head around.

re: F# Zen - ROT13

Patrick Dewane — Tue, 11 Nov 2008 21:29:08 GMT

Thanks for the explanation. It doesn't look like function composition from what I know of the subject. Knowing that ">>" is the function composition operator makes it really easy to read the line now, thanks again.

re: F# Zen - ROT13

Jay Hugard — Fri, 14 Nov 2008 11:31:22 GMT

This doesn't show clever use of function composition (very cool, by the way), but it does provide a traditional rot13 implementation:

let rot13 =

let rot b c = (int c - int b + 13) % 26 + int b |> char

String.map (function

| 'A'..'Z' as c -> rot 'A' c

| 'a'..'z' as c -> rot 'a' c

| c -> c )

re: F# Zen - ROT13

Frederico Pessoa — Wed, 06 May 2009 16:31:33 GMT

Summing all cents:

let rot13 s =

let rotc = function

| i when 97 <= i && i <= 122 -> (i - 84) % 26 + 97

| i when 65 <= i && i <= 90 -> (i - 52) % 26 + 65

| i -> i

s |> String.map (int >> rotc >> char)

re: F# Zen - ROT13

Frederico Pessoa — Wed, 06 May 2009 16:35:08 GMT

And I do miss python 0 <= x <= 100 construct...