Fixes for compatibility

Author: dbrattli

docs-src/dotnet/compatibility.md

@@ -6,26 +6,26 @@ Fable provides support for some classes of .NET BCL (Base Class Library) and mos
 
 The following classes are translated to JS and most of their methods (static and instance) should be available in Fable.
 
-.NET                                  | JavaScript
+.NET                                  | Python
 --------------------------------------|----------------------------
-Numeric Types                         | number
-Arrays                                | Array / Typed Arrays
+Numeric Types                         | int
+Arrays                                | array / bytearray
 Events                                | fable-core/Event
-System.Boolean                        | boolean
-System.Char                           | string
-System.String                         | string
-System.Guid                           | string
-System.TimeSpan                       | number
-System.DateTime                       | Date
-System.DateTimeOffset                 | Date
+System.Boolean                        | bool
+System.Char                           | str
+System.String                         | str
+System.Guid                           | guid
+System.TimeSpan                       | timedelta
+System.DateTime                       | datetime
+System.DateTimeOffset                 | timedelta
 System.Timers.Timer                   | fable-core/Timer
-System.Collections.Generic.List       | Array
+System.Collections.Generic.List       | List
 System.Collections.Generic.HashSet    | Set
-System.Collections.Generic.Dictionary | Map
-System.Text.RegularExpressions.Regex  | RegExp
+System.Collections.Generic.Dictionary | dict
+System.Text.RegularExpressions.Regex  | re
 System.Lazy                           | fable-core/Lazy
 System.Random                         | {}
-System.Math                           | (native JS functions)
+System.Math                           | math
 
 The following static methods are also available:
 
@@ -35,47 +35,58 @@ The following static methods are also available:
 - `System.Diagnostics.Debugger.Break()`
 - `System.Activator.CreateInstance<'T>()`
 
-There is also support to convert between numeric types and to parse strings, check [the conversion tests](https://github.com/fable-compiler/Fable/blob/master/tests/Main/ConvertTests.fs).
+There is also support to convert between numeric types and to parse
+strings, check [the conversion
+tests](https://github.com/fable-compiler/Fable/blob/master/tests/Main/ConvertTests.fs).
 
 ### Caveats
 
-- All numeric types become JS `number` (64-bit floating type), except for `int64`, `uint64`, `bigint` and `decimal`. Check the [Numeric Types](numbers.md) section to learn more about the differences between .NET and JS.
-- Numeric arrays are compiled to [Typed Arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) when possible.
+- All numeric types become Python `int` (64-bit floating type), except for `decimal`. Check the [Numeric
+  Types](numbers.md) section to learn more about the differences between .NET and Python.
+- Numeric arrays are compiled to [array](https://docs.python.org/3/library/array.html) when possible. Numeric arrays of
+  `uint8` are compiled to [bytearray](https://docs.python.org/3/library/array.html#bytearrays) in order to support
+  libraries that expect e.g `bytes` as input.
 - No bound checks for numeric types (unless you do explicit conversions like `byte 500`) nor for array indices.
-- `Regex` will always behave as if passed `RegexOptions.ECMAScript` flag (e.g., no negative look-behind or named groups).
 
 ## FSharp.Core
 
-Most of FSharp.Core operators are supported, as well as formatting with `sprintf`, `printfn` or `failwithf` (`String.Format` is also available).
-The following types and/or corresponding modules from FSharp.Core lib will likewise translate to JS:
+Most of FSharp.Core operators are supported, as well as formatting with `sprintf`, `printfn` or `failwithf`
+(`String.Format` is also available). The following types and/or corresponding modules from FSharp.Core lib will likewise
+translate to JS:
 
-.NET              | JavaScript
+.NET              | Python
 ------------------|----------------------------------------------------------
-Tuples            | Array
+Tuples            | tuple
 Option            | (erased)
 Choice            | fable-core/Choice
 Result            | fable-core/Result
 String            | fable-core/String (module)
-Seq               | [Iterable](http://babeljs.io/docs/learn-es2015/#iterators-for-of)
+Seq               | [Iterable](ttps://docs.python.org/3/library/collections.abc.html#collections.abc.Iterable)
 List              | fable-core/List
 Map               | fable-core/Map
 Set               | fable-core/Set
 Async             | fable-core/Async
+Task              | [Awaitable](https://docs.python.org/3/library/asyncio-task.html#awaitables)
 Event             | fable-core/Event (module)
 Observable        | fable-core/Observable (module)
-Arrays            | Array / Typed Arrays
+Arrays            | array / bytearray
 Events            | fable-core/Event
 MailboxProcessor  | fable-core/MailboxProcessor (limited support)
 
 ### Caveats II
 
-- Options are **erased** in Python (`Some 5` becomes just `5` in Python and `None` translates to `null`). This is needed for example, to represent Python [optional properties](https://docs.python.org/3/library/typing.html#typing.Optional). However in a few cases (like nested options) there is an actual representation of the option in the runtime.
+- Options are **erased** in Python (`Some 5` becomes just `5` in Python and `None` translates to `None`). This is needed
+  for example, to represent Python [optional properties](https://docs.python.org/3/library/typing.html#typing.Optional).
+  However in a few cases (like nested options) there is an actual representation of the option in the runtime.
 - `Async.RunSynchronously` is not supported.
-- `MailboxProcessor` is single-threaded in Python and currently only `Start`, `Receive`, `Post` and `PostAndAsyncReply` are implemented (`cancellationToken` or `timeout` optional arguments are not supported).
+- `MailboxProcessor` is single-threaded in Python and currently only `Start`, `Receive`, `Post` and `PostAndAsyncReply`
+  are implemented (`cancellationToken` or `timeout` optional arguments are not supported).
 
 ## Object Oriented Programming
 
-Most of F# OOP features are compatible with Fable: interfaces and abstract classes, structs, inheritance, overloading, etc. However, please note that due to some limitations of [ES2015 classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) the generated code uses the [prototype chain](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain) instead. Also note that instance members are not attached to the prototype, which means they won't be accessible from native JS code. The exception to this rule are the implementations of **interface and abstract members**.
+Most of F# OOP features are compatible with Fable: interfaces and abstract classes, structs, inheritance, overloading,
+etc. However, please note that instance members are not attached to the prototype, which means they won't be accessible
+from native JS code. The exception to this rule are the implementations of **interface and abstract members**.
 
 ### Caveats III
 
@@ -85,7 +96,8 @@ Most of F# OOP features are compatible with Fable: interfaces and abstract class
 
 There is some reflection support in Fable, you can check the [reflection tests](https://github.com/fable-compiler/Fable/blob/master/tests/Main/ReflectionTests.fs) to see what is currently possible.
 
-Generics are erased by default in the generated Python code. However, it is still possible to access generic information (like `typeof<'T>`) at runtime by marking functions with `inline`:
+Generics are erased by default in the generated Python code. However, it is still possible to access generic information
+(like `typeof<'T>`) at runtime by marking functions with `inline`:
 
 ```fsharp
 let doesNotCompileInFable(x: 'T) =