Functional Programming

1398 readers

1 users here now

founded 1 year ago

MODERATORS

Ategon

cercerilla

How to convert imperative side-effectful program to functional (in Ocaml)? (lemy.lol)

submitted 9 months ago by [email protected] to c/functional_programming

7 comments fedilink hide all child comments

I've been enjoying learning ocaml, but I found it very easy to write code riddled with side effects and imperative-ness.

Take this example:

let some_func arg = 
  let input = format_input_from_stdin ()
  let read_content = read_file "some/file/path.txt"
  let to_write = get_write_file_content input read_content
  let () = write_file "some/other/path.txt" to_write 
  let output = run_external_command_with_output 
  (output, read_content)

As you can see, many side effects and imperative steps in the code. Is there a better practice for coding this in a functional manner?

you are viewing a single comment's thread
view the rest of the comments

[–] [email protected] 1 points 9 months ago* (last edited 9 months ago)

For IO, you really can't. Haskell uses a conceit that your program is a functional state transformer that operates on the contents of the RealWorld (there is an actual object of type RealWorld in the GHC runtime). The idea is that your program's input is a RealWorld state which contains you looking at a blank screen, and its output is a state where your screen says "hello world". There are no side effects, just an input and an output. This transformer is then handed off to the runtime which is seen as a simple imperative interpreter separate from Haskell. But of course, under the hood, the above scheme (the "IO Monad") is just an imperative sub-language within Haskell, whose effectfulness is kept contained by the type system.

For pure computation things are different, and you use a different set of idioms and data structures than imperative programmers are used to. A familiar example is using recursion instead of iteration. Less obvious is lookup structures: instead of hash tables (which you'd normally update imperatively) you use balanced tree structures where an "update" operation takes an old tree, and returns a new tree that shares most of its structure with the old one, with a few items changed. Then you rely on garbage collection to get rid of old items that are no longer reachable. There is an entire very good book "Purely Functional Data Structures" by Chris Okasaki, about such structures. The book is sort of old now, but still well worth reading.

For more about how effectfulness is actually handled in Haskell, see the article "Tackling the Awkward Squad" by Simon PJ, https://research.microsoft.com/en-us/um/people/simonpj/papers/marktoberdorf/mark.pdf .