1. Home
  2. /
  3. Mercury Typing Test
  4. /
  5. Factorial Calculator

Factorial Calculator - Mercury Typing CST Test

Skip to main content
CodeSpeedTest
Languages
Start TypingJump into a test — pick any languageAdaptive TrainingUnlock chars as you master themPractice DrillsFocused sessions targeting weak spotsDaily ChallengesNew coding challenges every dayRace ModeCompete against others in real timeAI OpponentRace against an AI at your WPM levelTournamentsLive coding speed tournamentsArcade GamesZType, Overkill Survival, Glyphica & moreGamificationXP, coins, badges & quests
LeaderboardGlobal rankings for every languageCertificatesEarn verifiable Bronze / Silver / Gold certsActivityDaily streaks & historical analyticsProfileYour stats, badges & achievements
Browse Languages500+ languages with real code examplesBlogTips, guides & deep divesFree ToolsWPM calculator, typing speed report & moreFAQCommon questions answeredGetting StartedNew to CodeSpeedTest?AboutOur story & missionSupportGet help — Pro users get priorityContactGet in touch with the team
Pricing
Mode:
Duration:
1
2
3
4
5
6
7
8
9
10
11
12
:- module factorial.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.

:- func fact(int) = int.
fact(0) = 1.
fact(N) = N * fact(N-1).

main(!IO) :- io.write_int(fact(5), !IO), io.write_string("\n", !IO).
Coding works best on desktop or with an external keyboard.
CodeSpeedTest

Improve your coding speed, code accuracy, and programming syntax WPM with practice sessions across 500+ programming languages.

Quick Links

HomeAboutFeaturesGetting StartedLanguages

Legal & Support

Pro ⚡ PricingContactPrivacy PolicyTerms of Service

Connect

CodeSpeedTest on GitHubCodeSpeedTest on TwitterEmail CodeSpeedTest

© 2026 CodeSpeedTest. All rights reserved.

Factorial Calculator — Mercury Code

Calculates factorial using a pure function.

:- module factorial.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.

:- func fact(int) = int.
fact(0) = 1.
fact(N) = N * fact(N-1).

main(!IO) :- io.write_int(fact(5), !IO), io.write_string("\n", !IO).

Mercury Language Guide

Mercury is a purely declarative logic programming language with strong typing, determinism analysis, and a focus on reliability and performance. It is designed for building large-scale, maintainable, and efficient logic programs while avoiding common pitfalls of traditional Prolog systems.

Primary Use Cases

  • ▸Logic-based and symbolic programming
  • ▸Constraint solving
  • ▸Knowledge representation
  • ▸Formal verification and theorem proving
  • ▸Academic research and teaching

Notable Features

  • ▸Purely declarative semantics
  • ▸Strong, static type system
  • ▸Mode and determinism checking
  • ▸High-performance compiler
  • ▸Separation of logic and control flow

Origin & Creator

Mercury was created in the mid-1990s by Zoltan Somogyi, Fergus Henderson, and Thomas Conway at the University of Melbourne, building on ideas from Prolog but with stricter type and mode systems.

Industrial Note

Mercury is used in academic research, formal verification, symbolic computation, and complex rule-based systems. While not mainstream, it is highly valued in areas requiring highly reliable logic programs.

Quick Explain

  • ▸Mercury emphasizes declarative programming, separating logic from control flow.
  • ▸It provides a strong static type system and mode system for arguments.
  • ▸Mercury’s compiler optimizes for performance and guarantees no runtime type errors for well-typed programs.

Core Features

  • ▸Predicates and functions with explicit types
  • ▸Modes defining input/output arguments
  • ▸Determinism categories (det, semidet, nondet, multi)
  • ▸Module system for code organization
  • ▸Automatic memory management and garbage collection

Learning Path

  • ▸Learn basic logic programming concepts
  • ▸Understand types, modes, and determinism
  • ▸Practice predicate and function definitions
  • ▸Build small logic modules
  • ▸Progress to large declarative systems

Practical Examples

  • ▸Family tree reasoning
  • ▸Constraint satisfaction problems
  • ▸Symbolic math computations
  • ▸Natural language parsing
  • ▸Rule-based expert systems

Comparisons

  • ▸Mercury vs Prolog: stronger typing, mode and determinism system, better performance
  • ▸Mercury vs Haskell: functional vs logic paradigm, Mercury is declarative logic
  • ▸Mercury vs Python: specialized for logic, smaller ecosystem
  • ▸Mercury vs Lisp: symbolic computation vs declarative logic
  • ▸Mercury vs C: higher-level declarative logic, less low-level control

Strengths

  • ▸Eliminates many runtime errors via type and mode checking
  • ▸Predictable declarative behavior
  • ▸Efficient execution through optimized compilation
  • ▸Highly maintainable large logic programs
  • ▸Facilitates reasoning about program correctness

Limitations

  • ▸Smaller ecosystem and community
  • ▸Steeper learning curve than Prolog for beginners
  • ▸Limited libraries for modern software development
  • ▸Not suitable for mainstream web or mobile apps
  • ▸Requires strict adherence to modes and types

When NOT to Use

  • ▸Web and mobile application development
  • ▸Real-time embedded systems
  • ▸Mainstream commercial software without logic reasoning
  • ▸Large-scale GUI applications
  • ▸Performance-critical numeric computing outside logic domain

Cheat Sheet

  • ▸:- module family.
  • ▸:- interface.
  • ▸:- import_module io.
  • ▸:- pred parent(string, string).
  • ▸parent('Alice', 'Bob').

FAQ

  • ▸Is Mercury still in use?
  • ▸Yes, primarily in research and education.
  • ▸Can Mercury integrate with C?
  • ▸Yes, via Foreign Function Interface (FFI).
  • ▸Is Mercury purely functional?
  • ▸It is purely declarative logic-based, not functional in the Haskell sense.
  • ▸Why learn Mercury?
  • ▸To build reliable logic-based programs and understand advanced logic programming concepts.

30-Day Skill Plan

  • ▸Week 1: Mercury syntax and types
  • ▸Week 2: Modes and determinism
  • ▸Week 3: Predicate and function writing
  • ▸Week 4: Module-based projects
  • ▸Week 5: Constraint solving and symbolic computation

Final Summary

  • ▸Mercury is a strongly typed, purely declarative logic programming language for building reliable, maintainable logic programs.
  • ▸It combines type, mode, and determinism analysis with high-performance compilation.
  • ▸Ideal for research, symbolic computation, and complex logic systems.

Project Structure

  • ▸Source files (.m)
  • ▸Interface files (.m)
  • ▸Modules for code organization
  • ▸Test cases for predicates/functions
  • ▸Documentation files

Monetization

  • ▸Academic research and publications
  • ▸Symbolic computation consulting
  • ▸Logic-based software solutions
  • ▸Educational courses in logic programming
  • ▸Prototyping AI and constraint systems

Productivity Tips

  • ▸Leverage static types and modes early
  • ▸Modularize predicates for clarity
  • ▸Test small logic components incrementally
  • ▸Use determinism analysis for optimization
  • ▸Integrate FFI for performance-critical tasks

Basic Concepts

  • ▸Predicates (relations between terms)
  • ▸Functions (deterministic computations)
  • ▸Types (user-defined and built-in)
  • ▸Modes (input/output specification)
  • ▸Determinism declarations (det, semidet, multi, nondet)

Official Docs

  • ▸Mercury Language Reference Manual
  • ▸Mercury Compiler User Guide
  • ▸University of Melbourne Mercury Resources
  • ▸Mercury Tutorials and Examples
  • ▸Mercury FFI Documentation

More Mercury Typing Exercises

Mercury Counter and Theme ToggleMercury Fibonacci SequenceMercury Prime CheckerMercury Sum of ListMercury Reverse StringMercury Multiplication TableMercury Celsius to FahrenheitMercury Simple Alarm SimulationMercury Random Walk Simulation

Practice Other Languages

CReactPythonC++RustTypeScriptKotlinPHPJavaC#RubyMqlCqlN1qlCypher