#functional programming

[kendyonline]

it'll get better , don't you trust me ?

[nixos-linux-official]

Robotgirl forces you to learn Haskell asmr

[cyncrovee]

the main reason i’m learning haskell is that i’m fairly certain that the key to immortality is understanding what a monad is/j

[pipewire-official]

fuuucckkk im such a looppilled mutablechud i gotta get on the lambda grind and recursionmaxx

[myzanilred]

Unlike many of the languages you're likely familiar with, microGRAM functions won't have formal arguments. Instead, the special arguments() function will return the list that was passed to the function when it was called, and it is the responsibility of the function to evaluate that list.

Basically, all microGRAM functions are variadic.

[track-maniac]

Feeling inspired by a post I saw a few months ago, I programmed a simple game of tic-tac-toe in python, in a single expression. Like regular functional programming, this means I can't mutate variables. But more than functional programming, this also means I can't

Declare variables at all

Declare functions

Use most loops and branch structures

The resulting program is 1730 characters long after removing all the non-strictly necessary whitespace and contains "lambda" 9 times.

The players are asked where they want to play using a number for each cell, in the configuration of a standard numpad. The program checks for invalid input too.

Source code under the cut

(lambda grid,toggle,players,cells_filled,print_grid,check_victory,ask_xy,validate_input,the_game:(lambda victor:print('=====\n'+('Draw.'if victor is None else f"{victor} wins!")))(the_game(grid,players,cells_filled,toggle,print_grid,check_victory,ask_xy,validate_input,the_game)))([[7,8,9],[4,5,6],[1,2,3]],True,['X','O'],0,lambda grid:print('\n'+'\n'.join(' '.join(map(str,ligne))for ligne in grid)),lambda grid,players:([player for player in players if any(set(grid[i][col]for i in[0,1,2])=={player}for col in[0,1,2])or any(set(grid[row])=={player}for row in[0,1,2])or set(grid[i][i]for i in[0,1,2])=={player}or set(grid[i][2-i]for i in[0,1,2])=={player}]+[None])[0],lambda players,toggle,grid,ask_xy,validate_input:validate_input(input(f"{players[toggle]}, place your symbol: "),grid,players,toggle,ask_xy,validate_input),lambda selection,grid,players,toggle,ask_xy,validate_input:(lambda selection,grid,players,toggle,ask_xy,validate_input:(selection%3,2-selection//3)if grid[2-selection//3][selection%3]not in players else ask_xy(players,toggle,grid,ask_xy,validate_input))(int(selection)-1,grid,players,toggle,ask_xy,validate_input)if len(selection)==1 and'0'<selection<='9'else ask_xy(players,toggle,grid,ask_xy,validate_input),lambda grid,players,cells_filled,toggle,print_grid,check_victory,ask_xy,validate_input,the_game:(print_grid(grid),the_game((lambda players,toggle,xy,grid:[[players[not toggle]if(j,i)==xy else grid[i][j]for j in[0,1,2]]for i in[0,1,2]])(players,toggle,ask_xy(players,not toggle,grid,ask_xy,validate_input),grid),players,cells_filled+1,not toggle,print_grid,check_victory,ask_xy,validate_input,the_game)if check_victory(grid,players)is None and cells_filled<9 else check_victory(grid,players))[1])

If you can't read any of this, don't worry, I can't either.

You can find the original code and a slightly more readable version on my gitlab: https://gitlab.com/Rijaja/gaae/-/tree/main/tttaae (but careful, the game is in French)

[tree-three]

"A Gentle Introduction to Haskell" it feels like i'm being hit in the head with bricks

[bythepowerofscience]

Explaining Monads like a Normal Person

Programming on main, yeah. This is a blogging site. Skip if you aren't into this.

If you look up the Wikipedia article on Monads, or any kind of explanation, they always overcomplicate the hell out of it.

"monads are a way to structure computations as a sequence of steps, where each step not only produces a value but also some extra information about the-"

what the hell are you talking about

You wanna know what monads are? They're actually stupid simple.

Any "object" is a combination of behavior and state. For example, a struct both holds data and has methods that act on it:

A monad is just an object that lets you give it behavior at runtime:

That's literally it. You give it a function to do, and it does it on the value it holds.

You'll often see these used for optional values - things that may or may not be what you expect at runtime:

"Optional<T>" (the value T could be present or absent)

"Either<X, Y>" (the value is either an X or a Y, but we don't know which yet)

You define behavior to be executed only if it's the right type, and it does nothing if it's the wrong type, all without you having to check.

You just tell it to do something regardless and it handles it:

It really is that simple. I hate how much bs people throw into it trying to explain these things.