Forem: Fabián Vega Alcota

Typeclass in Python with Sparrow

Fabián Vega Alcota — Sat, 25 Mar 2023 17:00:42 +0000

Lately I've been working on a library called Sparrow. This library was born from the need to have a collection of tools to make it easier to develop in Python using a declarative approach, mainly in the composition of functions. Here I've created a collection of functions and decorators, and I've also implemented a Haskell inspired typeclass.

What is a Typeclass?

The typeclass concept is a very powerful tool used by languages like Haskell that allows us to create types of types. It is a way of using polymorphism through types. In Haskell we can define a typeclass like this:

class Eq a where
    (==) :: a -> a -> Bool
    a == b = not (a /= b)

    (/=) :: a -> a -> Bool
    a /= b = not (a == b)

In the example above, Eq is defined as a "type of types" for comparing the equality of two values. The great thing about this is that we can define, for example, that the arguments of the function are of type Eq, and the compiler will check if the types of the arguments are of type Eq. So we can do generic functions like this:

same :: (Eq a) => a -> a -> Bool
same a b = a == b

This function will work for any type that has the Eq typeclass.

Using Sparrow we can the same in Python:

from sparrow.kind import Kind, kind_function

class Eq(Generic[T], Kind):
    @kind_function(True)
    def eq(self: "Eq[T]", other: "Eq[T]"):
        return not self.neq(other)

    @kind_function(True)
    def neq(self: "Eq[T]", other: "Eq[T]"):
        return not self.eq(other)


def same(a: Eq[T], b: Eq[T]) -> bool:
    return a.eq(b)

You can see that the definition of this type (I will refer to it as "kind") is very similar in both languages using Sparrow. The main difference is that in Python we need to use a decorator to define the polymorphic functions and specify if they have a default implementation.

How to use it?

This library facilitates data modelling. This means that we can model our system using types and functions. We can use the power of the type system to make our code safer and easier to understand.

Let's see an example.

from sparrow.kind import Kind, kind_function
from sparrow.datatype import DataType

class Speaker(Kind):
    @kind_function
    def speak(speaker: "Speaker"):
        pass

class Runner(Kind):
    @kind_function(has_default=True)
    def start_running(runner: "Runner") -> None:
        print("I'm running")

    @kind_function(has_default=True)
    def stop_running(runner: "Runner") -> None:
        print("I'm not running")

class Animal(Speaker, Runner, DataType):
    pass

@dataclass
class Dog(Animal):
    def speak(self):
        print("Woof woof")

@dataclass
class Cat(Animal):
    def speak(self):
        print("Meow...")

    def start_running(self):
        print("I'm a cat, I won't run")

    def stop_running(self):
        print("You can't stop me")

dog = Dog()
cat = Cat()

dog.speak() # Woof woof
cat.speak() # Meow...

dog.start_running() # I'm running
dog.stop_running() # I'm not running

cat.start_running() # I'm a cat, I won't run
cat.stop_running() # You can't stop me

This is nothing new, we can do the same thing in Python using simple inheritance. But the difference is that a typeclass is a more declarative way of doing it. It makes the code more readable by composing types and performing operations on them (product and sum of types).

Error handling

In languages like Python, Java, C# and [insert your favorite OOP language]. It is common to use try-catch blocks to handle the errors, but this can add unnecessary complexity to using the result value.

def divide(a: int, b: int) -> int:
    return a / b

try:
    result = divide(10, 2)
except ZeroDivisionError:
    do_something()

Here we can refactor the code to use a functor called Result or Either in other languages to handle exceptions. This is a very common pattern in functional programming. We can do it like this:

from sparrow.datatype.result import Result, Success, Failure

def divide(a: int, b: int) -> Result[int, str]:
    if b == 0:
        return Failure("Division by zero")
    return Success(a // b)

divide(10, 0) # Failure("Division by zero")
divide(10, 2) # Success(5)

Or better:

from sparrow.decorator.wrap import result

@result
def divide_v2(a: int, b: int) -> Result[int, Exception]:
    return a // b

divide(10, 0) # Failure(ZeroDivisionError)
divide(10, 2) # Success(5)

Now if we want to use the result we can simply map the value.

result = divide(10, 0) # Failure(ZeroDivisionError)
result.fmap(lambda x: x * 2) # Failure(ZeroDivisionError)

And with other values:

result = divide(10, 2) # Success(5)
result.fmap(lambda x: x * 2) # Success(10)

Inclusive we can compose more operations:

result = (
    divide(10, 2) # Success(5)
    .fmap(lambda x: x * 2) # Success(10)
    .fmap(lambda x: x + 1) # Success(11)
    .fmap(lambda x: x % 2) # Success(1)
    .fmap(lambda x: "Even" if x == 0 else "Odd") # Success("Odd")
).value # "Odd"

Result also is a Bifunctor and we can use first, second, and bimap to map the first, second, or both possible values.

result = divide(10, 0) # Failure(ZeroDivisionError)
result.first(lambda x: x * 2) # Failure(ZeroDivisionError)
result.second(lambda x: repr(x)) # Failure("ZeroDivisionError()")
result.bimap(lambda x: x * 2, lambda x: repr(x)) # Failure("ZeroDivisionError()")

Here the definition of Functor and Bifunctor is not relevant, these are just functional patterns and in this case, we are using them to handle errors.

Maybe

Maybe is another very common pattern in functional programming. It is used to handle optional values, and it is very similar to the Result type, but it returns a value or nothing.

from sparrow.datatype.maybe import Maybe, Just, Nothing

def divide(a: int, b: int) -> Maybe[int]:
    if b == 0:
        return Nothing()
    return Just(a // b)

divide(10, 0) # Nothing()
divide(10, 2) # Just(5)

Or if we prefer to use the decorator:

from sparrow.decorator.wrap import maybe

@maybe
def divide(a: int, b: int) -> Optional[int]:
    return a // b if b != 0 else None

divide(10, 0) # Nothing()
divide(10, 2) # Just(5)

The decorator will map an optional return value to a Maybe type.

Maybe is a Functor, Applicative, and Monad. This means that we can use fmap, apply, and bind.

result = divide(10, 2) # Just(5)
result.fmap(lambda x: x * 2) # Just(10)
result.apply(Just(lambda x: x * 2)) # Just(10)
result.bind(lambda x: Just(x * 2)) # Just(10)

Also, the Maybe has a method called pure that is used to create a Just value.

from sparrow.datatype.maybe import Maybe

Maybe.pure(1) # Just(1)

The pure function can be used by any type that implements the Applicative typeclass.

Others tools

Sparrow also offers other functions tools. Here some examples:

Currying

Currying is a technique to transform a function with multiple arguments into a function with a single argument. This is very useful when we want to use partial application. For example:

from sparrow.decorator.currify import currify

@currify
def add(a: int, b: int) -> int:
    return a + b

add_one = add(1) # A function with one argument
add_one(2) # 3

Composition

Composition is a technique to combine two or more functions.

from sparrow.decorator.compose import compose

@compose(lambda x: x * 2, lambda x: x + 1)
def add_one_and_double(x: int) -> int:
    return x

add_one_and_double(1) # 4
add_one_and_double(2) # 6

The idea is to make pipelines of functions with more easily to modularize the code.

Reflex

Reflex is intended to debug the code or produce a side effect to finish the execution.

from sparrow.decorator.reflex import reflex

@reflex(lambda x: print(f"The value is {x}"))
def add_one(x: int) -> int:
    return x + 1

add_one(1)
# stdout: The value is 2

If we want to debug we can use debug, info, warning, error, and critical decorators.

from sparrow.decorator.reflex import debug, info, warning, error, critical

@critical
@error
@warning
@info
@debug
def add_one(x: int) -> int:
    return x + 1

add_one(1)
# stdout:
# DEBUG:root:2
# INFO:root:2
# WARNING:root:2
# ERROR:root:2
# CRITICAL:root:2

Also we can format the message.

from sparrow.decorator.reflex import info

@info("The value is {0}")
def add_one(x: int) -> int:
    return x + 1

add_one(1)
# stdout: INFO:root:The value is 2

Before and After

Before and after are decorators to execute a function before or after the execution of the decorated function.


from sparrow.decorator.before_after import before, after

@after(str)
@before(int)
def add_one(x: int) -> int:
    return x + 1

add_one(1.1) # "2"

When

The decorator

When is a decorator to execute a function when a condition is true.


from sparrow.decorator.when import when

@when(lambda x: x > 0)
def add_one(x: int) -> int:
    return x + 1

add_one(1) # 2
add_one(-1) # -1

The function

When is also a function to execute a function when a condition is true.

from sparrow.function.when import when

def divide(a: int, b: int) -> int:
    return when(
        condition=b != 0,
        then=lambda x: x / b,
        otherwise=lambda x: 0,
        value=a
    )

divide(10, 2) # 5
divide(10, 0) # 0

Map when

Map when is a function to execute a function when a condition is true and map the result.

from sparrow.function.when import map_when

my_list = [1, 2, 3, 4, 5]

map_when(
    condition=lambda x: x % 2 == 0,
    then=lambda x: x * 2,
    value=my_list
) # [1, 4, 3, 8, 5]

Conclusion

All tools must be used with care and preferably with strict type checking. The purpose of this library is to help you write more declarative code, and make data modelling and function composition more flexible.

This library is still under development and I am open to suggestions and contributions. The repository is available on GitHub. The documentation is not yet available, but I am working on it.

Building a REST API with Haskell

Fabián Vega Alcota — Tue, 12 Jul 2022 03:43:35 +0000

This is an example of REST API built with Scotty a web framework of Haskell and PostgreSQL a relational database. It's a simple API to manage products.

Index

Index
Running PostgreSQL
JSON REST API
- Declaring the routes of the API
- The product data type
  - Resume about how to use the Functors and Applicatives
- Get products
- Get one product
- Add a product
- Update and Delete a product
  - Check if the product exists
Quick run instructions
What is next?

Running PostgreSQL

This tutorial tries to be as simple to understand as possible, but if you know how to use docker-compose and use a PostgreSQL database, you can skip this section.

The first step is make a docker-compose.yml file.

version: "3"

services:
  database:
    build: ./db
    container_name: production-db
    ports:
      - "5432:5432"
    env_file:
      - example.env
    volumes:
      - ./db/postgres:/var/lib/postgresql/data

The example.env file is a file with the following content:

POSTGRES_USER=postgres
POSTGRES_PASSWORD=123456
POSTGRES_DB=products

This file is used to configure the credentials of database.

In docker-compose.yml don't use a specific images of PostgreSQL, because it is declared in Dockerfile this way:

FROM postgres:alpine

ADD scripts/init.sql /docker-entrypoint-initdb.d

RUN chmod a+r /docker-entrypoint-initdb.d/*

EXPOSE 6666

Thus, the database is initialized with the file init.sql, only when the db is created. The file init.sql is a file with the following content:

CREATE TABLE IF NOT EXISTS products (
  id SERIAL PRIMARY KEY,
  name VARCHAR(255) NOT NULL UNIQUE,
  price INTEGER NOT NULL,
  description TEXT
);

INSERT INTO products (name, price, description) VALUES
('Product 1', 10, 'Description 1'),
('Product 2', 20, 'Description 2'),
('Product 3', 30, 'Description 3');

These queries create the table products and insert some products.

In this way the database is available in the port 5432 and the data is stored into db.

JSON REST API

The first part of the API is a JSON REST API, with the following endpoints:

Method	Route	Description
Get	http://localhost:8080/api/product/	Retrieve all products
Get	http://localhost:8080/api/product/:id	Retrieve a specific product
Post	http://localhost:8080/api/product/	Add a product
Put	http://localhost:8080/api/product/:id	Update a product
Delete	http://localhost:8080/api/product/:id	Delete a product

Declaring the routes of the API

The routes are declaring in the file Main.hs, but before, as it is common in Haskell, it is necessary to build a main function where the application is executing. Here where the connection to the database is also creating:

import Database.PostgreSQL.Simple

localPG :: ConnectInfo
localPG =
  defaultConnectInfo
    { connectHost = "0.0.0.0",
      connectDatabase = "products",
      connectUser = "postgres",
      connectPassword = "123456"
    }

main :: IO ()
main = do
  conn <- connect localPG
  {- continue -}

Then, for the routes, you can create a function with the routes to separate these processes.

import Lib
import Web.Scotty (delete, get, post, put, scotty)

routes :: Connection -> IO ()
routes conn = scotty 8080 $ do
  get "/api/product/" $ getProducts conn

  get "/api/product/:id" $ getProduct conn

  post "/api/product/" $ createProduct conn

  put "/api/product/:id" $ updateProduct conn

  delete "/api/product/:id" $ deleteProduct conn

This is called from main:

main :: IO ()
main = do
  conn <- connect localPG

  routes conn

The product data type

Before creating the functions to get the products and use it, you must create the product data type.

data Product = Product
  { idProduct :: Int,
    name :: String,
    price :: Int,
    description :: String
  }

This allows to receive the data from the database and manage it in a better way, but defining only the data type is not enough for Haskell to parse the data from the database to the Product type. To do this, we need to instance from the FromRow type class and define how the data is translated to the type we define.

Yes, Haskell also has a class, but it is not a class as in the OOP paradigm. It can be considered as a kind of types. For more information see the following explanation from Learn You a Haskell for Great Good!.

import Database.PostgreSQL.Simple.FromRow

instance FromRow Product where
  fromRow = Product <$> field <*> field <*> field <*> field

The operators <*> and <$> are explained in here

Now it only remains to do the same to be able to serialize the type Product to a JSON and vice versa. That is possible instancing from the type class FromJSON and ToJSON, in this way:

import Data.Aeson

instance FromJSON Product where
  parseJSON (Object o) =
    Product <$> o .:? "id" .!= 0
      <*> o .: "name"
      <*> o .: "price"
      <*> o .: "description"
  parseJSON _ = fail "Expected an object for Product"

This mean that now we have defined the function parseJSON, this receives a JSON and when this JSON is an object, it will look for the fields id, name, price and description. For that, we use the .: and .:? operators, which means get field and maybe get field, correspondingly. And the operator .!= is used to set the default value for the field when it is not found. For example, when you receive a JSON object (called simplyo) {"name": "foo"} and you get the field "id" using o .:? "id" in this case you get a Nothing, but if next to it, you use .!= 0 then the result will be 0 for the id.

Resume about how to use the Functors and Applicatives

Haskell take advantage of the property of the Functors and Applicatives type classes.

The Functor type class has a function called fmap that allows to map a function over a functor, also can be used with the operator <$>.

The Applicatives is like a "subclass" of the Functor type class, and has a function called <*> that allows to apply a function wraped into a functor to a other functor.

So, when we use <$> and <*> means, take the constructor of type Product and apply it to the result to get a field. We still need more fields to have a Product type, so now it is a function wrapped by a functor. To apply the wrapped function, we use <*> and so on until we construct the Product type with all its fields.

And similarly to convert a Product type to a JSON:

import Data.Aeson

instance ToJSON Product where
  toJSON (Product idProduct name price description) =
    object
      [ "id" .= idProduct,
        "name" .= name,
        "price" .= price,
        "description" .= description
      ]

The object function is used to create a JSON object, and the .= assigns a value to a field in the object.

Get products

The function getProducts is a function that response a list of products.

Why have I said that the function response a list of products and not return a list of products?
That's because the function truly return a ActionM (), this is similar to IO monad and it is way to produce side effects.

import Control.Monad.IO.Class (liftIO)
import Database.PostgreSQL.Simple
import Web.Scotty (ActionM)
import qualified Web.Scotty as S

getProducts :: Connection -> ActionM ()
getProducts conn = do
  products <- (liftIO $ query_ conn "SELECT * FROM products") :: ActionM [Product]
  S.json $ object ["products" .= products]

line 6	This function receives a connection to the database and returns an empty `ActionM`, this is very similar to a `IO` monad, but in simple words, it provides a response to the client.

This is the way that Haskell control the side effects for maintain the referential transparency since Haskell is a pure functional language.

line 7	Save connection into `conn`.

line 8 This executes the query to get all the saved products.
The query_ function is very similar to query the difference is that this one does not receive values to replace in the query.
Also, the result of this query is interpreting as an IO [Product] type and liftIO is a function that take a IO a and transform to m a value, where m is another Monad. That is, it transforms IO [Product] result of query_ into ActionM [Product], that is why the :: operator is using here, to give information to Haskell about final type.

line 9	This return a `json` with an object that into have `"products"` with a list of products.

So, if you query the route http://localhost:8080/api/product/ you get something like this:

{
  "products": [
    {
      "description": "Description 1",
      "id": 1,
      "name": "Product 1",
      "price": 10
    },
    {
      "description": "Description 2",
      "id": 2,
      "name": "Product 2",
      "price": 20
    },
    {
      "description": "Description 3",
      "id": 3,
      "name": "Product 3",
      "price": 30
    }
  ]
}

Get one product

The function getProduct is a function that retrieve a id product and response a product.

import Data.Aeson
import Database.PostgreSQL.Simple
import Network.HTTP.Types.Status (status200, status400)
import Web.Scotty (ActionM, param, status)

getProduct :: Connection -> ActionM ()
getProduct conn = do
  _idProduct <- param "id" :: ActionM Int
  let result = query conn "SELECT * FROM products WHERE id = ?" (Only _idProduct)
  product <- liftIO result :: ActionM [Product]
  case product of
    [] -> do
      status status400
      S.json $ object ["error" .= ("Product not found" :: String)]
    _ -> do
      status status200
      S.json (head product)

line 2	This function is similar to the `getProducts` function, but it receives the identifier of some product, for this the `param` function is using, and the result is setting as an `ActionM Int` type.

line 3	Here we use the `query` function, it can format any query using values wrapped with `Only`. Thus, we get a custom query by adding `'?'` where a field should be added.

line 5 - line 11	Depending on the result of the query, it is possible to obtain an empty list or a list with at least one value, and the best way to declare this is with pattern matching. If the list is empty the result is a status code 400 and a message of error, else if the list have at least one value return a status code 200 and the first value of the list.

Add a product

The function createProduct is very similar to the previous functions. A different thing is that here is used the execute function and not query, which is used to execute a query and return the number of rows affected. This result is used to determine if the product was created or not. Other different is that now we use the jsonData function to get the JSON data from the request, for this work we created the intances of the FromJSON typeclass.

import Data.Aeson
import Database.PostgreSQL.Simple
import Network.HTTP.Types.Status (status201, status400)
import Web.Scotty (ActionM, param, status)


createProduct :: Connection -> ActionM ()
createProduct conn = do
  (Product _ _name _price _description) <- jsonData
  let result =
        execute
          conn
          "INSERT INTO products (name, price, description) VALUES (?, ?, ?)"
          (_name, _price, _description)
  n <- liftIO result
  if n > 0
    then do
      status status201
      S.json $ object ["message" .= ("Product created" :: String)]
    else do
      status status400
      S.json $ object ["error" .= ("Product not created" :: String)]

Update and Delete a product

And so on, the function updateProduct and deleteProduct are similar to the previous functions, but for do more easy to know if the product exists or not, we going to create the function hasProduct to check if the product exists.

import Data.Aeson
import Database.PostgreSQL.Simple
import Network.HTTP.Types.Status (status200, status204)
import Web.Scotty (ActionM, jsonData, param, status)

updateProduct :: Connection -> ActionM ()
updateProduct conn = do
  _idProduct <- param "id" :: ActionM Int

  (Product _ _name _price _description) <- jsonData :: ActionM Product

  productExist <- liftIO $ haveProduct conn _idProduct

  if not productExist
    then createProduct conn
    else do
      let result =
            execute
              conn
              "UPDATE products SET name = ?, price = ?, description = ? WHERE id = ?"
              (_name, _price, _description, _idProduct)
      n <- liftIO result
      status $ if n > 0 then status200 else status204
      S.json $ object ["message" .= ("Product updated" :: String)]

deleteProduct :: Connection -> ActionM ()
deleteProduct conn = do
  _idProduct <- param "id" :: ActionM Int

  productExist <- liftIO $ haveProduct conn _idProduct

  if not productExist
    then do
      status status400
      S.json $ object ["error" .= ("Product not found" :: String)]
    else do
      status status200
      liftIO $ execute conn "DELETE FROM products WHERE id = ?" (Only _idProduct)
      S.json $ object ["message" .= ("Product deleted" :: String)]

Check if the product exists

import Database.PostgreSQL.Simple

haveProduct :: Connection -> Int -> IO Bool
haveProduct conn _idProduct = do
  [Only n] <- query conn "SELECT COUNT(*) FROM products WHERE id = ?" (Only _idProduct) :: IO [Only Int]
  return $ n > 0

Quick run instructions

Before to start, you need to have stack and docker-compose installed.

For running the API, you need to run the database using docker-compose, first is necessary to build the images and later create and start the containers with next commands:

$ docker-compose build
$ docker-compose up

Once start the database, install dependencies and run the API:

$ stack install
$ stack run

What is next?

This tutorial try to explain how you can create a REST API using Haskell and use a database to store the data. This is a first part of the tutorial, and the next step is to manage HTML pages, for that we continue using Scotty and added the library Blaze.

The project can be found here and if you have any question, please contact me on Twitter or put a comment here.

Building a Wordle clone with Haskell

Fabián Vega Alcota — Mon, 27 Jun 2022 01:46:32 +0000

Do you remember the game called Wordle? The game that was trendy not long ago.

And sure, if you are a programmer, you have seen a lot of versions of this game with different languages and technologies. Now I'm going to show you, how to make this game in the language Haskell, loved by a few, hated by others and ignored by many.

Before you begin, it is necessary that install stack to install some packages.

The game read a list of words with animals.

main :: IO ()
main = do
  let filename = "animals.txt"
  animalsText <- readFile filename
  {- continue -}

For this, I use readFile with the firm:

readFile :: FilePath -> IO String

This means that when entering the file name we will receive an IO String and to “unwrap” the IO monad we will use the Haskell do-notation, that way we get the text with the file content.

Besides, to get a list with all words with the same format, we use the next code:

import Control.Monad (join)
import Data.Text (toLower, pack)
import qualified Data.Text as T


main :: IO ()
main = do
  let filename = "animals.txt"
  animalsText <- readFile filename
  let animals =
        join
          . map T.words
          . T.lines
          . toLower
          . pack
          $ animalsText
  {- continue -}

You can imagine the process to build animals like a pipe that going from the bottom to the top. So animalsText first pass by pack that transform a String to a Text, toLower transform all text to lowercase, lines split the lines and map T.words to each line split in words and finally join all in a list.

In Haskell for use of random numbers (pseudo-randoms), we will use the package random. The next step is to choose a random word of the list. For this, we must make a seed:

import System.Random (getStdGen, randomR)

main :: IO ()
main = do
  {- continue -}

  g <- getStdGen
  let selected_index = fst $ randomR (0 :: Int, length animals) g
  let selected_word = animals !! selected_index

  {- continue -}

The one I named g, later generate a random number, selected_index in the range 0 to the length of animals and getting the word in that index using (!!) function.

In Haskell the operators also are functions.

We already have a random word chosen from a file, now we have to program the logic of the game, for this I created a play function.

main :: IO ()
main = do
  let filename = "animals.txt"
  animalsText <- readFile filename
  let animals =
        join
          . map T.words
          . T.lines
          . toLower
          $ pack animalsText

  g <- getStdGen
  let selected_index = fst $ randomR (0 :: Int, length animals) g
  let selected_word = animals !! selected_index

  wordles <- play selected_word
  {- continue -}

The play function:

import Data.Text
  ( Text,
    pack,
    strip,
    toLower,
    unpack,
  )
import qualified Data.Text as T
import qualified Data.Text.IO as TIO
import Text.Printf (printf)

play :: Text -> IO [Text]
play selected_word = go attempts []
  where
    go :: Int -> [Text] -> IO [Text]
    go 0 xs = return xs
    go n xs = do
      let i = 1 + length xs

      putStrLn $ "Please enter your animal " ++ show i ++ "/" ++ show attempts ++ ": "

      attemptstr <- getLine
      let attempt = toLower . strip $ pack attemptstr
      let (wordle, correct) = getWordle attempt selected_word

      printf "Rustle (ES) %d/%d\n\n" i attempts

      TIO.putStrLn wordle

      if correct
        then do
          putStrLn "Congratulation!"
          printf "Rustle (ES) %d/%d\n\n" i attempts
          return (wordle : xs)
        else do
          go (n - 1) (wordle : xs)

Let's go by parts, play :: Text -> IO [Text] receive the select word and return all games. In the definition of play, I created an auxiliary function called go, that receive the attempts and an empty list. This function iterate the games, i.e., ask the user a word, show the result and while as long as it does not run out of plays or win, the game continue in the recursion.

The function return is not the same that the statement return of others languages mainly imperatives. In Haskell the function are composition of function, since what follows the equals is what defines the function.
return wrap the value in a Monad, in this case IO Monad.

Other function important is getWordle, which is defined as:

getWordle :: Text -> Text -> (Text, Bool)
getWordle attempt correct =
  let result = T.zipWith go attempt correct
      rest =
        if T.length attempt < T.length correct
          then pack $ replicate (T.length correct - T.length attempt) $ cshow Fail
          else mempty
      isCorrect = attempt == correct
   in (result <> rest, isCorrect)
  where
    go :: Char -> Char -> Char
    go ca cc
      | ca == cc = cshow Success
      | ca `elem` unpack correct = cshow Misplace
      | otherwise = cshow Fail

The function (<>) is a operator to concat two Semigroups, in this case, two Text, for example "foo" <> "bar" = "foobar".

This receives two Text types, attempt and correct, i.e., the attempt of user and the correct word. Haskell has the Let syntax, here we're going to define result.

The strategic that I thought was map the attempt and the correct word together, with some function that check if is success, misplace or fail. The function zipWith does that, apply zip to two lists and call a function with each pair values. In resume is a map and zip composed.

The go function, receive the two values and if are equals then marked as Success, if the character is in the correct word then is a Misplace else is Fail.

If the attempt word is more shore than the correct then the result in screen was going to be more short too, to solve this rest contain the rest of result, but only if correct is more long than attempt. Lastly, isCorrect ask if attempt and correct are equals.

Also, I defined some others things like:

{-# LANGUAGE LambdaCase #-}

data State = Fail | Success | Misplace

cshow :: State -> Char
cshow = \case
  Fail -> '⬜'
  Success -> '🟩'
  Misplace -> '🟨'

attempts :: Int
attempts = 6

I made a data type named State and defined cshow that return the character according to a State. And attempts that return the attempt amount of game.

Later to finish the game the program show the games, for this:

main :: IO ()
main = do
  ...

  wordles <- play selected_word

  TIO.putStrLn . T.unlines . reverse $ wordles

I use putStrLn from Data.Text.IO because the chars ['⬜', '🟩', '🟨'] are Unicode, of this way this characters are show in the console correctly.

The Game in operation

And with this we are able to play Wordle from our console.

$ stack run
Please enter your animal 1/6: 
elephant
Rustle (ES) 1/6

⬜🟨⬜⬜
Please enter your animal 2/6: 
duck
Rustle (ES) 2/6

⬜⬜⬜⬜
Please enter your animal 3/6: 
lark
Rustle (ES) 3/6

🟨⬜⬜⬜
Please enter your animal 4/6: 
mule
Rustle (ES) 4/6

⬜⬜🟨⬜
Please enter your animal 5/6: 
slug
Rustle (ES) 5/6

⬜🟨⬜⬜
Please enter your animal 6/6: 
fowl
Rustle (ES) 6/6

🟩🟩🟩🟩
Congratulation!
Rustle (ES) 6/6

⬜🟨⬜⬜
⬜⬜⬜⬜
🟨⬜⬜⬜
⬜⬜🟨⬜
⬜🟨⬜⬜
🟩🟩🟩🟩

Now you can develop your own Wordle clone with Haskell or the language you prefer. If you have comments or questions, share it in comments.

I share with you the link to the repository.

FabianVegaA / WordleHs

A simple Wordle clone made with Haskell.

WordleHs

This is a simple Wordle clone made with Haskell.

Run Game

Is necessary install stack a package manager of Haskell.

stack run

Explication

Do you remember the game called Wordle? The game that was trendy not long ago.

Before you begin, it is necessary that install stack to install some packages.

The game read a list of words with animals.

main :: IO ()
main = do
  let filename = "animals.txt"
  animalsText <- readFile filename
  ...

For this, I use readFile with the firm:

readFile :: FilePath -> IO String

This means that when entering the file name we…

View on GitHub