fix typos

CHANGELOG.md

@@ -42,7 +42,7 @@
   * This version no longer integrates a continuous time solver. A continuous simulation framework based on [DISCO](http://www.akira.ruc.dk/~keld/research/DISCO/) and inspired by the standalone [QSS](https://sourceforge.net/projects/qssengine/) solver using ConcurrentSim as its discrete-event engine can be found in the repository [QuantizedStateSystems](https://github.com/BenLauwens/QuantizedStateSystems.jl.git) (WIP):
   * Documentation is automated with [Documenter.jl](https://github.com/JuliaDocs/Documenter.jl) (WIP: Overview and Tutorial OK).
 * v0.4.1 (2017)
-  * the `@resumable` and `@yield` macros are put in a seperate package [ResumableFunctions](https://github.com/BenLauwens/ResumableFunctions.jl.git):
+  * the `@resumable` and `@yield` macros are put in a separate package [ResumableFunctions](https://github.com/BenLauwens/ResumableFunctions.jl.git):
   * Users have to take into account the following syntax change: `@yield return arg` is replaced by `@yield arg`.
 * v0.4 (2017) only supports Julia v0.6 and above. It is a complete rewrite: more julian and less pythonic. The discrete event features are on par with v0.3 (SimPy v3) and following features are added:
   * Scheduling of events can be done with `Base.Dates.Datetime` and `Base.Dates.Period`

docs/src/examples/Latency.md

@@ -4,7 +4,7 @@
 There is a built-in [`DelayQueue`](@ref) if you need a store [`Store`](@ref) with latency between `put!` and `take!` events. However here, we show you how you could have built one for yourself. If you modify this in order to construct a particularly useful type of latency store, please contribute it to the library through a pull request.
 
 ## Description 
-In this example we show how to separate the time delay between processes from the processes themselves. We model a communications channel, called a `Cable`, where a sender sends messages regularly each `SEND_PERIOD` time units and a receiver listens each `RECEIVE_PERIOD`. The messages in the cable have a delay fo `DELAY_DURATION` until they reach the recevier.
+In this example we show how to separate the time delay between processes from the processes themselves. We model a communications channel, called a `Cable`, where a sender sends messages regularly each `SEND_PERIOD` time units and a receiver listens each `RECEIVE_PERIOD`. The messages in the cable have a delay of `DELAY_DURATION` until they reach the receiver.
 
 ### Load Packages
 

docs/src/examples/mmc.md

@@ -20,7 +20,7 @@ num_customers = 10 # total number of customers generated
 num_servers = 2 # number of servers
 mu = 1.0 / 2 # service rate
 lam = 0.9 # arrival rate
-arrival_dist = Exponential(1 / lam) # interarrival time distriubtion
+arrival_dist = Exponential(1 / lam) # interarrival time distribution
 service_dist = Exponential(1 / mu) # service time distribution
 
 # define customer behavior

docs/src/guides/environments.md

@@ -70,7 +70,7 @@ By default, the simulation starts at time 0, but you can pass an `initial_time`
 Note
 
 !!! note
-    Although the simulation time is technically unitless, you can pretend that it is, for example, in milliseconds and use it like a timestamp returned by `Base.Dates.datetime2epochm` to calculate a date or the day of the week. The `Simulation` constructor and the `run` function accept as argument a `Base.Dates.DateTime` and the `timeout` constructor a `Base.Dates.Delay`. Together with the convenience function `nowDateTime` a simulation can transparantly schedule its events in seconds, minutes, hours, days, ...
+    Although the simulation time is technically unitless, you can pretend that it is, for example, in milliseconds and use it like a timestamp returned by `Base.Dates.datetime2epochm` to calculate a date or the day of the week. The `Simulation` constructor and the `run` function accept as argument a `Base.Dates.DateTime` and the `timeout` constructor a `Base.Dates.Delay`. Together with the convenience function `nowDateTime` a simulation can transparently schedule its events in seconds, minutes, hours, days, ...
 
 The function `active_process` is comparable to `Base.Libc.getpid` and returns the current active `Process`. If no process is active, a `NullException` is thrown. A process is active when its process function is being executed. It becomes inactive (or suspended) when it yields an event.
 

test/test_events.jl

@@ -13,7 +13,7 @@ end
 sim = Simulation()
 ev1 = Event(sim)
 @callback test_callback_event(ev1)
-succeed(ev1, value="Succes")
+succeed(ev1, value="Success")
 ev2 = Event(sim)
 @callback test_callback_event(ev2)
 fail(ev2, TestException())