You might well presumably also unbiased bear heard of us hiss that purposeful programming is extra academic, and unswerving engineering is carried out in crucial fashion. I’m going to show you that unswerving engineering is purposeful, and I’m going to illustrate it using a computer game that’s designed by engineers for engineers. It’s a simulation game known as Factorio, all over which you will be able to even be given resources that you would also bear gotten to in finding, develop factories that course of them, make an increasing number of complex systems, till you would even be at final in an arena to initiate a spaceship which will use you faraway from an inhospitable planet. If right here’s no longer engineering at its purest then I don’t know what’s. And yet nearly all you win when taking half in this game has its purposeful programming counterparts and it might well also additionally be outmoded to present fashioned ideas of no longer greatest programming however additionally, to a couple extent, class realizing. So, with out extra ado, let’s soar in.


The constructing blocks of every programming language are capabilities. A purpose takes input and produces output. In Factorio they are known as assembling machines, or assemblers. Here’s an assembler that produces copper wire.

Must you lift up the first points about the assembler you’ll stumble on the recipe that it’s using. This one takes one copper plate and produces a pair of coils of copper wire.

This recipe is if truth be told a purpose signature in a strongly typed plan. We stumble on two forms: copper plate and copper wire, and an arrow between them. Also, for every copper plate the assembler produces a pair of copper wires. In Haskell we would expose this purpose as

makeCopperWire :: CopperPlate -> (CopperWire, CopperWire)

Not greatest win now we bear forms for masses of parts, however we can combine forms into tuples–right here it’s a homogenous pair (CopperWire, CopperWire). Must you’re no longer accustomed to Haskell notation, right here’s what it might well also peek admire in C++:

std::pair makeCopperWire(CopperPlate);

Here’s one other purpose signature within the sort of an assembler recipe:

It takes a pair of iron plates and produces an iron gear wheel. We might also write it as

makeGear :: (IronPlate, IronPlate) -> Instruments

or, in C++,

Instruments makeGear(IronPlate, IronPlate);

Many recipes require a mixture of in some other case typed substances, admire the one for producing pink science packs

We would expose this purpose as:

makeRedScience :: (CopperPlate, Instruments) -> RedScience

Pairs are examples of product forms. Factorio recipes utilize the plus place to indicate tuples; I bet right here’s on story of we on a standard basis read a sum as “this and this”, and “and” introduces a product form. The assembler requires each inputs to win the output, so it accepts a product form. If it required either one, we’d call it a sum form.

We can additionally tuple extra than two substances, as in this recipe for producing electronic circuits (or inexperienced circuits, as they are commonly known as)

makeGreenCircuit :: 
  (CopperWire, CopperWire, CopperWire, IronPlate) -> GreenCircuit

Now direct that you would also bear gotten at your disposal the raw ingeredients: iron plates and copper plates. How would you dart about producing pink science or inexperienced circuits? Here’s the set purpose composition kicks in. You might well presumably dart the output of the copper wire assembler because the input to the inexperienced circuit assembler. (You might quiet ought to tuple it with an iron plate.)

Similarly, you will be able to be in an arena to win the gear assembler with the pink science assembler.

The outcome is a brand recent purpose with the next signature

makeRedScienceFrom :: 
    (CopperPlate, IronPlate, IronPlate) -> RedScience

And right here’s the implementation:

makeRedScienceFrom (cu, fe1, fe2)=
    makeRedScience (cu, makeGear (fe1, fe2))

You originate with one copper plate and two iron plates. You feed the iron plates to the gear assembler. You pair the resulting gear with the copper plate and dart it to the pink science assembler.

Most assemblers in Factorio use a couple of argument, so I couldn’t draw up with a much less complicated example of composition, one which wouldn’t require untupling and retupling. In Haskell we on the whole utilize capabilities of their curried kind (we’ll draw attend to this later), so composition is easy there.

Composition is additionally a purpose of a class, so we might also unbiased quiet save a query to the request if we can treat assemblers as arrows in a class. Their composition is clearly associative. But win now we bear an an identical of an id arrow? It is miles something that takes input of some form and returns it attend unchanged. And certainly now we bear issues known as inserters that win precisely that. Here’s an inserter between two assemblers.

If truth be told, in Factorio, you would also bear gotten to make utilize of an inserter for say composition of assemblers, however that’s an implementation element (technically, inserting an id purpose doesn’t trade anything else).

An inserter is if truth be told a polymorphic purpose, correct admire the id purpose in Haskell

inserter :: a -> a
inserter x=x

It works for any form a.

But the Factorio class has extra development. As now we bear considered, it helps finite merchandise (tuples) of arbitrary forms. This form of class is called cartesian. (We’ll focus on the unit of this product later.)

Take into story that now we bear identified a whole lot of Factorio subsystem as capabilities: assemblers, inserters, compositions of assemblers, and heaps others. In a programming language they’d all be correct capabilities. If we had been to build a language basically basically based mostly on Factorio (we might also call it Functorio), we would enclose the composition of assemblers into an assembler, and even kind an assembler that takes two assemblers and produces their composition. That might well be the next-expose assembler.

Larger expose capabilities

The defining purpose of purposeful languages is the flexibility to kind capabilities top quality objects. That methodology the flexibility to dart a purpose as an argument to one other purpose, and to draw attend a purpose on story of 1 other purpose. For instance, we must bear a recipe for producing assemblers. And, certainly, there might be such recipe. All it wants is inexperienced circuits, some gear wheels, and a few iron plates:

If Factorio had been a strongly typed language all of the draw, there might well be separate recipes for producing different assemblers (that’s assemblers with different recipes). For instance, we might also bear:

makeRedScienceAssembler :: 
   (GreenCircuit, Instruments, IronPlate) -> RedScienceAssembler

As a substitute, the recipe produces a generic assembler, and it lets the participant manually situation the recipe in it. In a draw, the participant presents one final ingredient, an element of the enumeration of all that you will be able to be in an arena to judge of recipes. This enumeration is displayed as a menu of picks:

In spite of the whole lot, Factorio is an interactive game.

Since now we bear identified the inserter because the id purpose, we must bear a recipe for producing it as neatly. And certainly there might be one:

Cease we additionally bear capabilities that use capabilities as arguments? In numerous words, recipes that utilize assemblers as input? Certainly we win:

Another time, this recipe accepts a generic assembler that hasn’t been assigned its beget recipe yet.

This presentations that Factorio helps better-expose capabilities and is certainly a purposeful language. What now we bear right here’s a draw of treating capabilities (assemblers) no longer greatest as arrows between objects, however additionally as objects that can even additionally be produced and consumed by capabilities. In school realizing, such objectified arrow forms are known as exponential objects. A class all over which arrow forms are represented as objects is called closed, so we can gape Factorio as a cartesian closed class.

In a strongly typed Factorio, we might also hiss that the thing RedScienceAssembler

is an associated to its recipe

form RedScienceAssembler=
    (CopperPlate, Instruments) -> RedScience

We might also then write the next-expose recipe that produces this particular assembler as:

makeRedScienceAssembler :: 
     (GreenCircuit, Instruments, IronPlate) 
  -> ((CopperPlate, Instruments) -> RedScience)

Similarly, in a strongly typed Factorio we would change this better-expose recipe

with the next signature

makeGreenScience :: ((a -> a), Belt) -> GreenScience

assuming that the inserter is a polymorphic purpose a -> a.

Linear forms

There might be one critical element of purposeful programming that appears to be like to be broken in Factorio. Functions are supposed to be pure: mutation is a no-no. And in Factorio we preserve talking about assemblers intriguing resources. A pure purpose doesn’t use its arguments–you would also unbiased dart the identical merchandise to many capabilities and this is able to quiet be there. Dealing with resources is a unswerving self-discipline in programming in frequent, including purely purposeful languages. Fortunately there are artful systems of facing it. In C++, for instance, we can utilize queer pointers and transfer semantics, in Rust now we bear ownership forms, and Haskell unbiased no longer too long ago provided linear forms. What Factorio does is terribly associated to Haskell’s linear forms. A linear purpose is a purpose that’s assured to use its argument. Functorio assemblers are linear capabilities.

Factorio is all about intriguing and transforming resources. The resources kind as diversified ores and coal in mines. There are additionally trees that can even additionally be chopped to yield wood, and liquids admire water or grievous oil. These external resources are then consumed, linearly, by your industry. In Haskell, we would implement it by passing a linear purpose known as a continuation to the helpful resource producer. A linear purpose guarantees to use the helpful resource entirely (no helpful resource leaks) and to no longer kind a whole lot of copies of the identical helpful resource. These are the guarantees that the Factorio industrial complex presents robotically.


Pointless to claim Factorio changed into no longer designed to be a programming language, so we can’t save a query to it to implement every element of programming. It is miles enjoyable though to mediate how we would translate some extra pleasant programming capabilities into Factorio. For instance, how would currying work? To enhance currying we would first need partial application. The premise is somewhat easy. We bear already considered that assemblers might also additionally be handled as first-class objects. Now agree with that you would also win assemblers with a situation recipe (strongly typed assemblers). For instance this one:

It’s a two-input assembler. Now give it a single copper plate, which in programmer train is called partial application. It’s partial on story of we haven’t provided it with an iron gear. We can judge of the outcome of partial application as a brand recent single-input assembler that expects an iron gear and is in an arena to win one beaker of pink science. By partly applying the purpose makeRedScience

makeRedScience :: (CopperPlate, Instruments) -> RedScience

now we bear created a brand recent purpose of the kind

Instruments -> RedScience

If truth be told now we bear correct designed a course of that gave us a (better-expose) purpose that takes a copper plate and creates a “primed” assembler that greatest wants an iron gear to win pink science:

makeGearToRedScience :: CopperPlate -> (Instruments -> RedScience)

In Haskell, we would implement this purpose using a lambda expression

makeGearToRedScience cu=gear -> makeRedScience (cu, gear)

Now we would rating to automate this course of. We desire to bear something that takes a two-input assembler, for instance makeRedScience, and returns a single input assembler that produces one other “primed” single-input assembler. The form signature of this beast might well be:

curryRedScienceAssembler ::
     ((CopperPlate, Instruments) -> RedScience)  -- RedScienceAssembler
  -> (CopperPlate -> (Instruments -> RedScience))

We would implement it as a double lambda:

curryRedScienceAssembler rsAssembler=
  cu -> (gear -> rsAssembler (cu, gear))

Take into story that it if truth be told doesn’t subject what the concrete forms are. What’s critical is that we can flip a purpose that takes a pair of arguments into a purpose that returns a purpose. We can kind it entirely polymorphic:

curry :: ((a, b) -> c) 
       -> (a -> (b -> c))

Here, the kind variables a, b and c might also additionally be replaced with any forms (critically, CopperPlate, Instruments, and RedScience).
Here’s a Haskell implementation:

curry f=a -> b -> f (a, b)


As much as now we haven’t talked about how arguments (gadgets) are delivered to capabilities (assemblers). We can manually fall gadgets into assemblers, however that very hasty turns into tiresome. We desire to automate the delivery systems. One arrangement of doing it’s by using some roughly containers: chests, prepare wagons, barrels, or conveyor belts. In programming we call these functors. Strictly speaking a functor can preserve greatest one sort of gadgets at a time, so a chest of iron plates ought to be a notify form than a chest of gears. Factorio doesn’t implement this however, in practice, we no longer continuously mix various kinds of gadgets in one container.

The critical property of a functor is that you will be able to be in an arena to practice a purpose to its contents. Here’s most positive illustrated with conveyor belts. Here we use the recipe that turns a copper plate into copper wire and practice it to a full conveyor belt of copper (coming from the beautiful) to win a conveyor belt of copper wire (going to the left).

The very fact that a belt can lift any sort of gadgets might also additionally be expressed as a form constructor–a records form parameterized by an arbitrary form a

records Belt a

You might well presumably practice it to any form to win a belt of notify gadgets, as in

Belt CopperPlate

We can mannequin belts as Haskell lists.

records Belt a=MakeBelt [a]

The very fact that it’s a functor is expressed by implementing a polymorphic purpose mapBelt

mapBelt :: (a -> b) -> (Belt a -> Belt b)

This purpose takes a purpose a->b and produces a purpose that transforms a belt of as to a belt of bs. So that you must make a belt of (pairs of) copper wire we’ll plan the assembler that implements makeCoperWire over a belt of CopperPlate

makeBeltOfWire :: (Belt CopperPlate) -> (Belt (CopperWire, CopperWire))
makeBeltOfWire=mapBelt makeCopperWire

You might well presumably also unbiased judge of a belt as such as a checklist of parts, or an loads of movement, looking on the draw you employ it.

In frequent, a form constructor F is called a functor if it helps the mapping of a purpose over its contents:

plan :: (a -> b) -> (F a -> F b)

Sum forms

Uranium ore processing is raring. It is miles carried out in a centrifuge, which accepts uranium ore and produces two isotopes of Uranium.

The recent element right here is that the output is probabilistic. More on the whole than no longer (on average, 99.3% of the time) you’ll win Uranium 238, and greatest once in some time (0.7% of the time) Uranium 235 (the glowy one). Here the plus place is outmoded to surely encode a sum form. In Haskell we would utilize the Both form constructor, which generates a sum form:

makeUranium :: UraniumOre -> Both U235 U238

In numerous languages you would also stumble on it known as a tagged union.

The two selections within the output sort of the centrifuge require different actions: U235 might also additionally be grew to change into into gas cells, whereas U238 requires reprocessing. In Haskell, we would win it by pattern matching. We would practice one purpose to address U235 and one other to address U238. In Factorio right here’s carried out using filter inserters (a.okay.a., pink inserters). A filter inserter corresponds to a purpose that picks regarded as one of many selections, for instance:

filterInserterU235 :: Both U235 U238 -> Maybe U235

The Maybe records form (or Non-indispensable in some languages) is outmoded to accommodate the chance of failure: you will be able to be in an arena to’t win U235 if the union contained U238.

Every filter inserter is programmed for a notify form. Below you stumble on two pink inserters outmoded to destroy up the output of the centrifuge into two different chests:

Incidentally, a mixed conveyor belt might also be considered as carrying a sum form. The gadgets on the belt might also be, for instance, either copper wire or steel plates, which will be written as Both CopperWire SteelPlate. You don’t even ought to make utilize of pink inserters to separate them, as any inserter turns into selective when associated to the input of an assembler. This is able to greatest settle up the gadgets that are the inputs of the recipe for the given assembler.

Monoidal functors

Every conveyor belt has two facets, so it’s pure to make utilize of it to transfer pairs. In particular, it’s that you will be able to be in an arena to judge of to merge a pair of belts into one belt of pairs.

We don’t utilize an assembler to win it, correct some belt mechanics, however we can quiet judge of it as a purpose. On this case, we would write it as

(Belt CopperPlate, Belt Instruments) -> Belt (CopperPlate, Instruments)

In the example above, we plan the pink science purpose over it

streamRedScience :: Belt (CopperPlate, Instruments) -> Belt RedScience
streamRedScience beltOfPairs=mapBelt makeRedScience beltOfPairs

Since makeRedScience has the signature

makeRedScience :: (CopperPlate, Instruments) -> RedScience

all of it form checks.

Since we can practice belt merging to any form, we can write it as a polymorphic purpose

mergeBelts :: (Belt a, Belt b) -> Belt (a, b)
mergeBelts (MakeBelt as, MakeBelt bs)=MakeBelt (zip as bs)

(In our Haskell mannequin, now we should zip two lists collectively to win a checklist of pairs.)

Belt is a functor. In frequent, a functor that has this roughly merging means is called a monoidal functor, on story of it preserves the monoidal development of the class. Here, the monoidal development of the Factorio class is given by the product (pairing). Any monoidal functor F ought to preserve the product:

(F a, F b) -> F (a, b)

There might be one extra element to monoidal development: the unit. The unit, when paired with anything else, does nothing to it. More precisely, a pair (Unit, a) is, for all intents and applications, an associated to a. Basically the most positive solution to realize the unit in Factorio is to avoid wasting a query to the request: The belt of what, when merged with the belt of a, will win a belt of a? The reply is: the belt of nothing. Merging an empty belt with any different belt, makes no difference.

So emptiness is the monoidal unit, and now we bear, for instance:

(Belt CopperPlate, Belt Nothing) -> Belt CopperPlate

The flexibility to merge two belts, alongside with the flexibility to make an empty belt, makes Belt a monoidal functor. In frequent, moreover maintaining the product, the condition for the functor F to be monoidal is the flexibility to win

F Nothing

Most functors, as a minimal in Factorio, will no longer be monoidal. For instance, chests can no longer store pairs.

Applicative functors

As I talked about sooner than, most assembler recipes use a whole lot of arguments, which we modeled as tuples (merchandise). We additionally talked about partial application which, surely, takes an assembler and regarded as one of many substances and produces a “primed” assembler whose recipe requires one much less ingredient. Now agree with that you would also bear gotten a full belt of a single ingredient, and you plan an assembler over it. In original Factorio, this assembler will accept one merchandise after which win stuck looking forward to the comfort. But in our prolonged version of Factorio, which we call Functorio, mapping a multi-input assembler over a belt of single ingredient might also unbiased quiet win a belt of “primed” assemblers. For instance, the pink science assembler has the signature

(CopperPlate, Instruments) -> RedScience

When mapped over a belt of CopperPlate it might well also unbiased quiet win a belt of partly applied assemblers, every with the recipe:

Instruments -> RedScience

Now direct that you would also bear gotten a belt of gears ready. You might bear to be in an arena to win a belt of pink science. If there greatest had been one arrangement to practice the first belt over the second belt. Something admire this:

(Belt (Instruments -> RedScience), Belt Instruments) -> Belt RedScience

Here now we bear a belt of primed assemblers and a belt of gears and the output is a belt of pink science.

A functor that helps this roughly merging is called an applicative functor. Belt is an applicative functor. If truth be told, we can repeat that it’s applicative on story of we’ve established that it’s monoidal. Certainly, monoidality lets us merge the two belts to win a belt of pairs

Belt (Instruments -> RedScience, Instruments)

Each person knows that there is a draw of applying the Instruments->RedScience assembler to a Instruments resulting in RedScience. That’s correct how assemblers work. But for the purpose of this argument, let’s give this application an notify title: eval.

eval :: (Instruments -> RedScience, Instruments) -> RedScience
eval (gtor, gr)=gtor gr

(gtor gr is correct Haskell syntax for applying the purpose gtor to the argument gr). We’re abstracting the fundamental property of an assembler that it might well also additionally be applied to an merchandise.

Now, since Belt is a functor, we can plan eval over our belt of pairs and win a belt of RedScience.

apBelt :: (Belt (Instruments -> RedScience), Belt Instruments) -> Belt RedScience
apBelt (gtors, gear)=mapBelt eval (mergeBelts (gtors, gears))

Going attend to our genuine self-discipline: given a belt of copper plate and a belt of gear, right here’s how we win a belt of pink science:

redScienceFromBelts :: (Belt CopperPlate, Belt Instruments) -> Belt RedScience
redScienceFromBelts (beltCu, beltGear)=
  apBelt (mapBelt (curry makeRedScience) beltCu, beltGear)

We curry the two-argument purpose makeRedScience and plan it over the belt of copper plates. We win a beltful of primed assemblers. We then utilize apBelt to practice these assemblers to a belt of gears.

To win a frequent definition of an applicative functor, it’s adequate to change Belt with generic functor F, CopperPlate with a, and Instruments with b. A funtor F is applicative if there is a polymorphic purpose:

(F (a -> b), F a) -> F b

or, in curried kind,

F (a -> b) -> F a -> F b

To whole the describe, we additionally need the an identical of the monoidal unit law. A purpose known as pure plays this purpose:

pure :: a -> F a

This correct repeat you that there’s one arrangement to make a belt with a single merchandise on it.


In Factorio, the nesting of functors is a superb deal puny. It’s that you will be able to be in an arena to judge of to win belts, and you will be able to be in an arena to avoid wasting them on belts, so you will be able to be in an arena to bear a beltful of belts, Belt Belt. Similarly you will be able to be in an arena to store chests inner chests. But you will be able to be in an arena to’t bear belts of loaded belts. You might well presumably’t settle a belt stuffed with copper plates and save it on one other belt. In numerous words, it’s doubtless you’ll maybe presumably no longer transport beltfuls of stuff. Realistically, that wouldn’t kind powerful sense in unswerving world, however in Functorio, right here’s precisely what we would prefer to implement monads. So agree with that you would also bear gotten a belt carrying a bunch of belts that are carrying copper plates. If belts had been monadic, you would also flip this whole element into a single belt of copper plates. This functionality is called join (in some languages, “flatten”):

join :: Belt (Belt CopperPlate) -> Belt CopperPlate

This purpose correct gathers all of the copper plates from all of the belts and locations them on a single belt. You might well presumably element of it as concatenating all of the subbelts into one.

Similarly, if chests had been monadic (and there’s no reason they shouldn’t be) we would bear:

join :: Chest (Chest Instruments) -> Chest Instruments

A monad ought to additionally toughen the applicative pure (in Haskell it’s known as return) and, genuinely, every monad is robotically applicative.


There are many different capabilities of Factorio that lead to keen topics in programming. For instance, the prepare plan requires facing concurrency. If two trains are attempting to enter the identical crossing, we’ll bear a records bustle which, in Functorio, is called a prepare rupture. In programming, we steer clear of records races using locks. In Factorio, they are known as prepare signals. And, after all, locks lead to deadlocks, which will be very exhausting to debug in Factorio.

In purposeful programming we might also utilize STM (Instrument Transactional Memory) to address concurrency. A prepare drawing draw a crossing would originate a crossing transaction. It could per chance maybe temporarily ignore all different trains and luckily kind the crossing. Then it might well are attempting to commit the crossing. The plan would then verify if, within the imply time, one other prepare has successfully commited the identical crossing. If so, it might well hiss “oops! are attempting yet again!”.

Read More

Recent Content